int longestValidParentheses(char * s){


    int stackIndex=0;
    int lastIndex=-1;
    int max1=0;
    int thisCount=0;
    int i;
    int indexLeft1=-1,indexRight1=0;

    char *p=s;
    while(*p)
    {

        switch(*p)
        {

            case '(': //正向遇到(入栈
                stackIndex++;
                if(lastIndex==-1)
                {
                    lastIndex=p-s;
                }
                break;

            case ')': //正向遇到)只要满足条件就出栈

                if(stackIndex<=0)
                {
                  
                  
			 /**
			 *  遇到无效字符就认为是终结符，需要判断当前计数是否比最大值大
			 *  并且需要反向验证一遍确定有效括号的数量
			 */
                    if(thisCount>0&&thisCount>=max1)
                    {

                    
                        indexRight1=p-1-s;
                        indexLeft1=lastIndex;
                        thisCount=reverlongest(s,indexLeft1,indexRight1);
                        if(thisCount>=max1)
                        {
                            max1=thisCount;    
                        }
                        
                    }
                    lastIndex=-1;

                  
                    stackIndex=0;
                    thisCount=0;

                }
                else
                {
                    stackIndex--;
                    thisCount++;
                }

                break;

        }

        p++;
    }

    if(thisCount>0&&thisCount>=max1)
    {

        indexRight1=p-1-s; 
        indexLeft1=lastIndex;
        thisCount=reverlongest(s,indexLeft1,indexRight1);         
          if(thisCount>=max1)
            {
                max1=thisCount;    
            }
      
    }

    
  
   return max1*2;
}


/**
 *反向验证字符串s从l到r是否是真的符合有效括号
并且返回有效括号数量
 *
 */
int reverlongest(char *s,int l,int r)
{

    int stackIndex=0;
    int lastIndex=-1;
    int max1=0;
    int thisCount=0;
    char *p=s+r;

    if(l<0)
    {
        l=0;
    }
    while(p>=s+l)
    {

        switch(*p)
        {

            case ')': //遇到)入栈
                stackIndex++;
                break;
            case '('://遇到(只要满足出栈条件就出栈，否则就认为无效字符
                if(stackIndex<=0)
                {
		/**
 		*  遇到无效字符就认为是终结符，需要判断当前计数是否比最大值大
 		*    
		 */
                    if(thisCount>=max1)
                    {
                           max1=thisCount; 
                    }
                    stackIndex=0;
                    thisCount=0;
                  
                }
                else
                {
                    stackIndex--;
                    thisCount++;
                }
                break;
            

        }

        p--;
    }

 /**
 *遇到末尾也是终结符，需要判断当前计数是否比最大值大
 */
 if(thisCount>0&&thisCount>=max1)
    { 
        max1=thisCount;
    }

    return max1;
}
